package com.dingding.service.usermangerservice.impl;

import java.util.Date;
import java.util.List;
import org.apache.log4j.Logger;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Restrictions;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.dingding.bean.databean.push.PushData;
import com.dingding.bean.databean.push.PushUserLogin;
import com.dingding.bean.databean.request.ReqBackPassword;
import com.dingding.bean.databean.request.ReqResetPassword;
import com.dingding.bean.databean.request.ReqSetDepositPassword;
import com.dingding.bean.databean.request.ReqUserLogin;
import com.dingding.bean.databean.request.ReqUserLoginByNum;
import com.dingding.bean.databean.request.ReqUserLogout;
import com.dingding.bean.databean.request.ReqUserRegister;
import com.dingding.bean.databean.request.ReqVerifyDepositNum;
import com.dingding.bean.databean.request.ReqVerifyDepositPwd;
import com.dingding.bean.databean.request.ReqVerifyLoginPwd;
import com.dingding.bean.databean.response.DataResponse;
import com.dingding.bean.databean.response.ResUserLogin;
import com.dingding.bean.databean.response.ResUserLoginByNum;
import com.dingding.bean.databean.response.ResUserRegion;
import com.dingding.bean.entity.Phonevalidate;
import com.dingding.bean.entity.UserLogin;
import com.dingding.bean.entity.Useraccount;
import com.dingding.bean.entity.Userdetail;
import com.dingding.bean.entity.Userorder;
import com.dingding.bean.entity.Vehicleinfo;
import com.dingding.common.core.config.ServiceCode;
import com.dingding.common.core.config.SystemCode;
import com.dingding.common.core.util.DateFormatUtil;
import com.dingding.common.core.util.JSONUtil;
import com.dingding.common.core.util.ToolUtil;
import com.dingding.dao.sql.UserLoginServiceSQL;
import com.dingding.service.BaseService;
import com.dingding.service.usermangerservice.IUserLoginService;
import com.dingding.util.SendPushUtil;

@SuppressWarnings("all")
/**
 * 
 * @ClassName: UserLoginServiceImpl
 * @Description:用户登录操作service
 * @author cheshaowei
 * @date 2015-10-21 上午10:28:27
 */
public class UserLoginServiceImpl extends BaseService implements IUserLoginService {

	private static final Logger log = Logger.getLogger(UserLoginServiceImpl.class);
	
	//验证码剩余次数(连续失败五次，则当天不能进行验证)
	private Integer validateFailNumber = 0;

	/**
	 * 
	 * @Title: getUserLoginInfo
	 * @Description:获取用户登录信息
	 * @param userId
	 *            用户ID
	 * @author cheshaowei
	 * @Override
	 * 
	 */
	@Transactional(readOnly = true)
	public UserLogin getUserLoginInfo(String userId, DataResponse dataResponse) {

		// 用户登录信息对象
		UserLogin userLogin = null;

		try {

			userLogin = super.userLoginDao.getById(userId, false);
		} catch (Exception e) {
			// 查询异常
			log.error("获取用户登录信息出现异常", e);
			setStatus(dataResponse, SystemCode.ERROR);
			return null;
		}
		// 没有查询到信息
		if (userLogin == null) {
			setStatus(dataResponse, SystemCode.USER_INFO_NOT_EXIST_ERROR);
			return null;
		}

		return userLogin;
	}

	/**
	 * 
	 * @Title: resetPassword
	 * @Description:重置密码
	 * @param reqResetPassword
	 *            请求bean
	 * @param dataResponse
	 *            返回信息封装bean
	 * @author fengshuonan
	 * @throws @Override
	 */
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public void resetPassword(ReqResetPassword reqResetPassword, DataResponse dataResponse) {

		// 验证重置密码时传入参数是否为空
		boolean flag = this.validateResetPassword(reqResetPassword);

		// 判断请求是否为空
		if (!flag) {
			// 返回状态码（请求数据为空）
			log.error("重置密码请求参数为空:" + reqResetPassword.toString());
			setStatus(dataResponse, SystemCode.DATA_NULL_ERROR);
			return;
		}

		// 获取重置密码的用户id
		String userId = reqResetPassword.getUserId();
		// 原始密码
		String oldPwd = reqResetPassword.getOldPwd();
		// 新密码
		String newPwd = reqResetPassword.getNewPwd();
		// 用户登陆表对象
		UserLogin userLogin = null;
		// 根据用户id和密码，创建查询条件
		Criterion criterion = Restrictions.and(Restrictions.eq("uid", userId), Restrictions.eq("userPwd", oldPwd));

		try {

			// 查询用户id和密码是否匹配
			userLogin = super.userLoginDao.queryCriteriaUnResult(criterion, false);

		} catch (Exception e) {
			log.error("通过用户id和用户密码查询对象出现错误！UserLoginServiceImpl 方法：resetPassword()", e);

			// 返回错误状态码
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 如果查询结果不为空
		if (userLogin != null) {
			// 设置新的用户密码
			userLogin.setUserPwd(newPwd);
			// 封装返回状态码（成功）
			setStatus(dataResponse, SystemCode.SUCCESS);

		} else {
			// 封装返回状态码（原密码不正确）
			setStatus(dataResponse, SystemCode.RESET_FAIL_ERROR);
		}
	}

	/**
	 * @Title: validateresetPassword @Description: 验证重置密码时传入的参数是否为空 @param
	 *         reqResetPassword 客户端传入参数 @return true 参数正确 false 参数有误 @throws
	 */
	public boolean validateResetPassword(ReqResetPassword reqResetPassword) {

		// 判断请求是否为空
		if (reqResetPassword == null // 重置密码传入参数是否为空
				|| ToolUtil.isBlank(reqResetPassword.getUserId()) // 用户Id是否为空
				|| ToolUtil.isBlank(reqResetPassword.getOldPwd()) // 旧密码是否为空
				|| ToolUtil.isBlank(reqResetPassword.getNewPwd())) { // 新密码是否为空

			return false;
		}

		return true;
	}

	/**
	 * @Title: backPassword
	 * @Description:找回密码
	 * @param backPassword
	 *            找回密码请求bean
	 * @param dataResponse
	 *            相应bean
	 * @author fengshuonan
	 * 
	 * @throws @Override
	 */
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public void backPassword(ReqBackPassword backPassword, DataResponse dataResponse) {

		// 验证找回密码时传入的参数是否为空
		boolean flag = this.validateBackPassword(backPassword);

		// 判断请求是否为空
		if (!flag) {
			// 返回状态码（请求数据为空）
			setStatus(dataResponse, SystemCode.DATA_NULL_ERROR);
			return;
		}

		// 获取用户名和新密码
		String userName = backPassword.getUserName();
		String newPwd = backPassword.getNewPwd();

		// 创建用户登录的对象
		UserLogin userLogin = null;
		// 根据用户名创建查询条件
		Criterion criterion = Restrictions.eq("userName", userName);

		try {

			// 查询用户信息
			userLogin = super.userLoginDao.queryCriteriaUnResult(criterion, false);

		} catch (Exception e) {
			log.error("重置用户密码时查询用户出现错误！UserLoginServiceImpl  方法:backPassword()", e);

			// 返回错误状态码
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 判断该用户信息是否为空
		if (userLogin == null) {
			// 返回错误状态码
			setStatus(dataResponse, SystemCode.USER_INFO_NOT_EXIST_ERROR);
			return;
		}

		// 更新用户密码
		userLogin.setUserPwd(newPwd);
		// 设置状态码（成功）
		setStatus(dataResponse, SystemCode.SUCCESS);
		return;

	}

	/**
	 * @Title: validatebackPassword @Description: 验证找回密码时传入参数是否为空 @param
	 *         backPassword 客户端传入参数 @return boolean 返回类型 @throws
	 */
	public boolean validateBackPassword(ReqBackPassword backPassword) {

		if (backPassword == null // 客户端传入参数是否为空
				|| ToolUtil.isBlank(backPassword.getNewPwd()) // 新密码是否为空
				|| ToolUtil.isBlank(backPassword.getUserName())) { // 用户名是否为空

			return false;
		}

		return true;
	}

	/**
	 * @Title: setStatus @Description: 设置找回密码相应返回码 @param dataResponse
	 *         响应信息封装bean @param status 状态码 @author fengshuonan @return
	 *         void @throws
	 */
	public void setStatus(DataResponse dataResponse, int status) {
		String message = null;

		switch (status) {
		case SystemCode.SUCCESS:// 请求成功
			message = SystemCode.SUCCESS_MESSAGE;
			break;
		case SystemCode.RESET_FAIL_ERROR:// 原密码不正确
			message = SystemCode.RESET_FAIL_MESSAGE;
			break;
		case SystemCode.LOGIN_FAIL_ERROR:// 用户名或密码错误
			message = SystemCode.LOGIN_FAIL_MESSAGE;
			break;
		case SystemCode.NOT_MATCH_ERROR:
			message = SystemCode.NOT_MATCH_MESSAGE;
			break;
		case SystemCode.WITHDRAWALS_FAIL_ERROR:// 提现密码输入不正确
			message = SystemCode.WITHDRAWALS_FAIL_MESSAGE;
			break;
		case SystemCode.DATA_NULL_ERROR:// 客户端请求数据为空
			message = SystemCode.DATA_NULL_MESSAGE;
			break;
		case SystemCode.ERROR:// 系统异常
			message = SystemCode.ERROR_MESSAGE;
			break;
		case SystemCode.USER_INFO_NOT_EXIST_ERROR:// 用户不存在
			message = SystemCode.USER_INFO_NOT_EXIST_MESSAGE;
			break;
		case SystemCode.REGISTER_USER_EXIST_ERROR:// 用户已存在
			message = SystemCode.REGISTER_USER_EXIST_MESSAGE;
			break;
		case SystemCode.USER_BLOCKED_ERROR: // 用户被锁定
			message = SystemCode.USER_BLOCKED_MESSAGE;
			break;
		case SystemCode.NICK_NAME_ILLEGAL_ERROR: // 用户昵称不合法
			message = SystemCode.NICK_NAME_ILLEGAL_MESSAGE;
			break;
		case SystemCode.VALIDATE_THROUGH_ERROR:// 手机验证码失效
			message = SystemCode.VALIDATE_THROUGH_MESSAGE;
			break;
		case SystemCode.VALIDATE_NOT_THROUGH_ERROR:// 验证码错误
			message = SystemCode.VALIDATE_NOT_THROUGH_MESSAGE(validateFailNumber);
			break;
		}

		dataResponse.setResponseCode(status);
		dataResponse.setResponseMessage(message);
	}

	/**
	 * @Title: setDepositPassword
	 * @Description:设置提现密码
	 * @param depositPassword
	 *            提现密码
	 * @param dataResponse
	 *            响应bean
	 * @author fengshuonan
	 * @throws @Override
	 */
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public void setDepositPassword(ReqSetDepositPassword depositPassword, DataResponse dataResponse) {

		// 验证设置提现密码时客户端传入的参数是否为空
		boolean flag = this.validateSetDepositPassword(depositPassword);

		// 如果请求为空
		if (!flag) {
			setStatus(dataResponse, SystemCode.DATA_NULL_ERROR);
			return;
		}

		// 用户id
		String userId = depositPassword.getUserId();
		// 提现密码
		String depositPwd = depositPassword.getDepositPwd();

		// 创建用于存储用户登录信息的UserLogin对象
		UserLogin login = this.getUserLoginInfo(userId, dataResponse);
		// 如果查询结果为空
		if (login == null) {
			return;
		}

		// 设置提现密码
		login.setDepositPwd(depositPwd);
		// 是否设置过提现密码 1：未设置 2：已设置
		login.setIsDeposit(2);
		// 设置响应信息（成功）
		setStatus(dataResponse, SystemCode.SUCCESS);

	}

	/**
	 * @Title: validateSetDepositPassword @Description: 验证设置提现密码时传入参数是否为空 @param
	 *         depositPassword 客户端传入的参数 @return boolean 返回类型 @throws
	 */
	public boolean validateSetDepositPassword(ReqSetDepositPassword depositPassword) {

		if (depositPassword == null // 设置提现密码时传入的参数是否为空
				|| ToolUtil.isBlank(depositPassword.getDepositPwd()) // 提现密码是否为空
				|| ToolUtil.isBlank(depositPassword.getUserId())) { // 用户Id是否为空

			return false;
		}

		return true;
	}

	/**
	 * @Title: verifyLoginPwd
	 * @Description:首次提现校验登录密码
	 * @param reqVerifyLoginPwd
	 *            请求bean
	 * @param dataResponse
	 *            响应bean
	 * @author fengshuonan
	 * @throws @Override
	 */
	@Transactional(readOnly = true)
	public void verifyLoginPwd(ReqVerifyLoginPwd reqVerifyLoginPwd, DataResponse dataResponse) {

		// 验证首次提现校验登录密码时传入参数是否为空
		boolean flag = this.validateVerifyLoginPwd(reqVerifyLoginPwd);

		// 判断请求是否为空
		if (!flag) {
			// 返回状态码（客户端请求数据为空）
			setStatus(dataResponse, SystemCode.DATA_NULL_ERROR);
			return;
		}

		// 获取请求具体内容
		// 当前用户Id
		String userId = reqVerifyLoginPwd.getUserId();
		// 登录账户
		String userName = reqVerifyLoginPwd.getUserName();
		// 登录密码
		String userPwd = reqVerifyLoginPwd.getUserPwd();

		UserLogin userLogin = null;
		// 根据请求信息封装查询条件
		Criterion criterion = Restrictions.and(Restrictions.eq("uid", userId), Restrictions.eq("userName", userName));
		try {

			// 根据条件，查询数据库有无记录
			userLogin = super.userLoginDao.queryCriteriaUnResult(criterion, false);

		} catch (Exception e) {
			log.error("首次提现校验登录密码时，查询用户信息错误！UserLoginServiceImpl 方法:verifyLoginPwd()", e);
			// 返回错误状态码
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 查无此用户
		if (userLogin == null) {
			// 返回用户不存在，用户id和用户名不属于同一个账户
			setStatus(dataResponse, SystemCode.NOT_MATCH_ERROR);
			return;
		} else if (ToolUtil.isNotBlank(userLogin.getUserPwd()) && userPwd.equals(userLogin.getUserPwd())) {
			// 返回成功状态码
			setStatus(dataResponse, SystemCode.SUCCESS);
			return;
		} else {
			// 密码错误
			setStatus(dataResponse, SystemCode.LOGIN_FAIL_ERROR);
			return;
		}

	}

	/**
	 * @Title: verifyDepositNum @Description:提现时校验提现密码 @param
	 *         reqVerifyDepositNum 校验提现密码bean @param dataResponse 响应bean @author
	 *         Li Yi @return void @throws
	 */
	@Transactional(propagation=Propagation.REQUIRED)
	public void verifyDepositNum(ReqVerifyDepositNum reqVerifyDepositNum, DataResponse dataResponse) {
		// 验证首次提现校验登录密码时传入参数是否为空

		// 判断请求是否为空
		if (reqVerifyDepositNum == null || ToolUtil.isBlank(reqVerifyDepositNum.getUserId())
				|| ToolUtil.isBlank(reqVerifyDepositNum.getUserName())
				|| ToolUtil.isBlank(reqVerifyDepositNum.getValidateNum())) {
			// 返回状态码（客户端请求数据为空）
			setStatus(dataResponse, SystemCode.DATA_NULL_ERROR);
			return;
		}

		// 获取请求具体内容
		// 当前用户Id
		String userId = reqVerifyDepositNum.getUserId();
		// 登录账户
		String userName = reqVerifyDepositNum.getUserName();
		// 验证码
		String userNum = reqVerifyDepositNum.getValidateNum();

		UserLogin userLogin = null;
		// 根据请求信息封装查询条件
		Criterion criterion = Restrictions.and(Restrictions.eq("uid", userId), Restrictions.eq("userName", userName));
		try {

			// 根据条件，查询数据库有无记录
			userLogin = super.userLoginDao.queryCriteriaUnResult(criterion, false);

		} catch (Exception e) {
			log.error("首次提现校验登录密码时，查询用户信息错误！UserLoginServiceImpl 方法:verifyLoginPwd()", e);
			// 返回错误状态码
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 获取验证码对象信息
		Phonevalidate phonevalidate = getPhonevalidate(userName, dataResponse);

		// 查无此用户
		if (userLogin == null) {
			// 返回用户不存在，用户id和用户名不属于同一个账户
			setStatus(dataResponse, SystemCode.NOT_MATCH_ERROR);
			return;
		}

		// 判断验证码信息是否存在
		if (phonevalidate == null || phonevalidate.getValidateNum() == null || phonevalidate.getCreateTime() == null) {
			log.info("验证码不存在");
			setStatus(dataResponse, SystemCode.DATA_NULL_ERROR);
			return;
		}

		// 判断验证码是否正确
		if (!phonevalidate.getValidateNum().equals(userNum)) {

			//判断验证码是否超过5次
			if(phonevalidate.getValidateCodeNumber() < 5){
				phonevalidate.setValidateCodeNumber(phonevalidate.getValidateCodeNumber() + 1);
			}
			
			//还剩几次机会
			validateFailNumber = 5 - phonevalidate.getValidateCodeNumber();
			
			setStatus(dataResponse, SystemCode.VALIDATE_NOT_THROUGH_ERROR);
			return;
		}

		// 判断验证码是否失效
		Date validateTime = phonevalidate.getCreateTime();
		boolean validateFlag = ToolUtil.validateTimeOut(validateTime);
		if (!validateFlag || phonevalidate.getIsValid() == 2) {
			setStatus(dataResponse, SystemCode.VALIDATE_THROUGH_ERROR);
			return;
		}

		if (userNum.equals(phonevalidate.getValidateNum())) {
			
			//验证通过，验证失败数量重置
			phonevalidate.setValidateCodeNumber(0);
			//是否有效
			phonevalidate.setIsValid(2);
			
			
			// 返回成功状态码
			setStatus(dataResponse, SystemCode.SUCCESS);
			return;
		} else {
			setStatus(dataResponse, SystemCode.LOGIN_FAIL_ERROR);
			return;
		}
	}

	/** 获取验证码信息 **/
	private Phonevalidate getPhonevalidate(String userName, DataResponse dataResponse) {
		Criterion criterion_Num = Restrictions.eq("phoneNum", userName);

		Phonevalidate phonevalidate = null;

		try {
			phonevalidate = super.phoneValidateDao.queryCriteriaUnResult(criterion_Num, false);
		} catch (Exception e) {
			log.error("查询验证码出现异常 类：" + this.getClass() + " getPhonevalidate()", e);
			setStatus(dataResponse, SystemCode.ERROR);
		}

		return phonevalidate;
	}

	/**
	 * @Title: validateVerifyLoginPwd @Description:
	 *         验证首次提现校验登录密码时客户端传入参数是否为空 @param reqVerifyLoginPwd 客户端传入参数 @return
	 *         boolean 返回类型 @throws
	 */
	public boolean validateVerifyLoginPwd(ReqVerifyLoginPwd reqVerifyLoginPwd) {

		if (reqVerifyLoginPwd == null // 首次提现校验登录密码客户端传入参数
				|| ToolUtil.isBlank(reqVerifyLoginPwd.getUserId()) // 用户Id是否为空
				|| ToolUtil.isBlank(reqVerifyLoginPwd.getUserName()) // 用户名是否为空
				|| ToolUtil.isBlank(reqVerifyLoginPwd.getUserPwd())) { // 密码是否为空

			return false;
		}

		return true;
	}

	/**
	 * @Title: verifyDepositPwd
	 * @Description:提现时校验提现密码
	 * @param reqVerifyDepositPwd
	 *            校验提现密码bean
	 * @param dataResponse
	 *            响应bean
	 * @author fengshuonan
	 * @throws @Override
	 */
	@Transactional(readOnly = true)
	public void verifyDepositPwd(ReqVerifyDepositPwd reqVerifyDepositPwd, DataResponse dataResponse) {

		// 验证提现时校验提现密码时传入的参数是否为空
		boolean flag = this.validateVerifyDepositPwd(reqVerifyDepositPwd);

		// 判断请求是否为空
		if (!flag) {
			// 返回状态码（客户端请求数据为空）
			setStatus(dataResponse, SystemCode.DATA_NULL_ERROR);
			return;
		}

		// 获取用户id
		String userId = reqVerifyDepositPwd.getUserId();
		// 获取用户名
		String userName = reqVerifyDepositPwd.getUserName();
		// 获取提现密码
		String depositPwd = reqVerifyDepositPwd.getDepositPwd();

		UserLogin userLogin = null;

		// 封装查询条件，根据用户id和手机号
		Criterion criterion = Restrictions.and(Restrictions.eq("userName", userName), Restrictions.eq("uid", userId));
		try {

			// 查询数据库本用户记录
			userLogin = super.userLoginDao.queryCriteriaUnResult(criterion, false);
		} catch (Exception e) {
			log.error("提现时校验提现密码！UserLoginServiceImpl 方法:verifyLoginPwd()", e);
			// 返回错误状态码
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 查无此用户记录
		if (userLogin == null) {
			// 返回用户不存在
			setStatus(dataResponse, SystemCode.USER_INFO_NOT_EXIST_ERROR);
		} else if (ToolUtil.isNotBlank(userLogin.getDepositPwd()) && userLogin.getDepositPwd().equals(depositPwd)) {
			// 返回请求成功状态码
			setStatus(dataResponse, SystemCode.SUCCESS);
		} else {
			// 返回 提现密码输入不正确 状态码
			setStatus(dataResponse, SystemCode.WITHDRAWALS_FAIL_ERROR);
		}
	}

	/**
	 * @Title: validateVerifyDepositPwd @Description:
	 *         提现时校验提现密码时客户端传入的参数是否为空 @param reqVerifyDepositPwd 客户端请求参数 @return
	 *         boolean 返回类型 @throws
	 */
	public boolean validateVerifyDepositPwd(ReqVerifyDepositPwd reqVerifyDepositPwd) {

		// 判断请求是否为空
		if (reqVerifyDepositPwd == null // 提现时校验提现密码时客户端请求参数是否为空
				|| ToolUtil.isBlank(reqVerifyDepositPwd.getDepositPwd()) // 提现密码是否为空
				|| ToolUtil.isBlank(reqVerifyDepositPwd.getUserName()) // 用户名是否为空
				|| ToolUtil.isBlank(reqVerifyDepositPwd.getUserId())) { // 用户Id是否为空

			return false;
		}

		return true;
	}

	/**
	 * @Title: userRegister
	 * @Description:用户注册
	 * @param userRegister
	 *            请求bean
	 * @param dataResponse
	 *            相应bean
	 * @author Li Yi
	 * @Override
	 */
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public void userRegister(ReqUserRegister reqUserRegister, DataResponse dataResponse) {

		// 验证用户注册时传入的参数是否为空
		boolean isTrue = this.validateuserRegister(reqUserRegister);

		if (!isTrue) {
			log.error("用户注册请求参数为空:" + reqUserRegister.toString());
			setStatus(dataResponse, SystemCode.DATA_NULL_ERROR);
			return;
		}
		// 昵称长度过长 或者 存在特殊表情符号
		if (reqUserRegister.getNickName().length() > 128
				|| !reqUserRegister.getNickName().matches(ServiceCode.NICK_NAME_CODE)) {
			setStatus(dataResponse, SystemCode.NICK_NAME_ILLEGAL_ERROR);
			return;
		}

		// 生成用户登录ID(根据当前时间戳和六位随机数拼接成一个用户的登录Id)
		String userLoginId = ToolUtil.getUid();
		// 生成用户详情ID
		String userDetailId = ToolUtil.getUid();
		// 生成用户账户ID
		String userAccountId = ToolUtil.getUid();
		// 生成用户积分ID
		String userIntegralId = ToolUtil.getUid();
		// 生成用户车主认证信息ID
		String vehicleinfoId = ToolUtil.getUid();

		// 用户登录信息保存到数据库
		try {
			super.userLoginDao.saveUserLogin(reqUserRegister, userLoginId);

		} catch (Exception e) {
			log.error("用户注册保存 登录表 存储发生异常, 类：" + this.getClass() + " 方法：userRegister()");
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 用户详情信息保存到数据库
		try {
			super.userDetailDao.saveUserDetail(reqUserRegister, userLoginId, userDetailId);
		} catch (Exception e) {
			log.error("用户注册保存 用户详情表 发生异常, 类：" + this.getClass() + " 方法：userRegister()");
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 用户账户信息保存到数据库
		try {
			super.userAccountDao.saveUserAccount(reqUserRegister, userAccountId, userLoginId);
		} catch (Exception e) {
			log.error("用户注册保存 账户信息表 发生异常, 类：" + this.getClass() + " 方法：userRegister()");
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 用户积分信息保存到数据库
		try {
			super.userIntegralDao.saveUserIntegral(reqUserRegister, userIntegralId, userLoginId);
		} catch (Exception e) {
			log.error("用户注册保存 积分信息表 发生异常, 类：" + this.getClass() + " 方法：userRegister()");
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 用户车主认证信息保存到数据库
		try {
			super.vehicleinfoDao.saveVehicleInfo(vehicleinfoId, userLoginId);
		} catch (Exception e) {
			log.error("用户注册保存 车主认证表 发生异常, 类：" + this.getClass() + " 方法：userRegister()");
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 注册响应bean
		ResUserRegion resUserRegion = new ResUserRegion(userLoginId);
		// 注册成功
		setStatus(dataResponse, SystemCode.SUCCESS);
		// 响应体
		dataResponse.setResponseBody(resUserRegion);

	}

	/**
	 * 
	 * @Title: validateuserRegister @Description: 验证用户注册时传入的参数是否为空 @param
	 *         reqUserRegister 客户端传入参数是否为空 @return true 参数正确 false 参数不正确 @throws
	 */
	private boolean validateuserRegister(ReqUserRegister reqUserRegister) {

		if (reqUserRegister == null) {
			return false;
		}
		// 手机号
		if (ToolUtil.isBlank(reqUserRegister.getTelphone())) {
			return false;
		}
		// 昵称
		if (ToolUtil.isBlank(reqUserRegister.getNickName())) {
			return false;
		}
		// 用户密码
		if (ToolUtil.isBlank(reqUserRegister.getUserPwd())) {
			return false;
		}
		// 登录设备
		if (reqUserRegister.getLoginEquipment() == null) {
			return false;
		}
		// 性别
		if (reqUserRegister.getSex() == null) {
			return false;
		}

		return true;
	}

	/**
	 * 
	 * @Title: userLogin @Description: 用户登录 @param reqUserLogin
	 *         客户端-用户登录请求bean @param dataResponse @author Li Yi @return
	 *         void @throws
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public void userLogin(ReqUserLogin reqUserLogin, DataResponse dataResponse) {
		// 验证用户登录时客户端传入参数是否为空
		boolean isTrue = this.validateUserLogin(reqUserLogin);

		if (!isTrue) {
			log.error("登录请求参数存在空值:" + reqUserLogin.toString());
			setStatus(dataResponse, SystemCode.DATA_NULL_ERROR);
			return;
		}

		// 用于接收所查询出的用户登录信息
		Object object = null;

		ResUserLogin resUserLogin = new ResUserLogin();

		// Phonevalidate phonevalidate = null;

		// //根据手机验证码创建查询条件
		// Criterion criterion_pwd = Restrictions.eq("userPwd",
		// reqUserLogin.getUserPwd());
		//
		try {
			// //获取用户验证码信息
			// phonevalidate = super..queryCriteriaUnResult(criterion_pwd,
			// false);
			// //判断手机验证码是否存在
			// if(phonevalidate == null){
			// log.error("获取验证码为空，类："+this.getClass()+"userLogin()");
			// setStatus(dataResponse, SystemCode.VALIDATE_NOT_THROUGH_ERROR);
			// return;
			// }
			// 查询用户，并得到用户详情ResUserLogin bean
			object = super.userLoginDao.getUserInfo(reqUserLogin, resUserLogin);

		} catch (Exception e) {
			log.error("用户登录异常, 类：" + this.getClass() + "userLogin()", e);
			setStatus(dataResponse, SystemCode.ERROR);// 网络异常
			return;
		}

		if (object instanceof UserLogin) {
			// 将返回值强转为UserLogin
			UserLogin userLogin = (UserLogin) object;
			// 设定用户状态
			int status = userLogin.getUserStatus();
			// 新的别名
			String newAliasId = ToolUtil.getUid();

			// 进行状态判定
			switch (status) {

			// 已退出
			case 2:

				// 更新登录设备
				userLogin.setLoginEquipment(reqUserLogin.getLoginEquipment());

				// 改变用户登录状态
				userLogin.setUserStatus(1);

				// 更新别名
				userLogin.setAliasId(newAliasId);

				// 更新手机标识
				userLogin.setImei(reqUserLogin.getImei());

				// 记录登录时间
				userLogin.setLastLoginTime(new Date());

				// 将newAliasId放入登录响应
				resUserLogin.setAliasId(newAliasId);

				// 响应请求
				dataResponse.setResponseBody(resUserLogin);

				// 登录成功
				setStatus(dataResponse, SystemCode.SUCCESS);// 200

				break;

			// 已登录
			case 1:

				// 如果请求的imei号为空或者与当前存的imei号不一致
				if (!reqUserLogin.getImei().equals(userLogin.getImei())) {

					// 推送Bean
					PushData pushData = new PushData();

					// 推送序号(时间戳)
					pushData.setRequestNumber(DateFormatUtil.getTimeInMillis().toString());
					// 推送时间
					pushData.setRequestTime(DateFormatUtil.yyyy_MM_dd_HHmmss());
					// 模块
					pushData.setModular(ServiceCode.USER_LOGIN);
					// 响应内容
					PushUserLogin pushUserLogin = new PushUserLogin(DateFormatUtil.yyyy_MM_dd_HHmmss(),
							reqUserLogin.getLoginEquipment() == 1 ? "iOS" : "Android");

					pushData.setResponseBody(pushUserLogin);

					String json = JSONUtil.toJSONString(pushData);

					// 面向用户推送信息
					SendPushUtil.sendPush(userLogin.getAliasId(), "", "", json,
							userLogin.getLoginEquipment() == 1 ? "iOS" : "Android");

					// 推送后更新用户新的极光别名
					userLogin.setAliasId(newAliasId);

					// 推送后更新用户新的手机标识
					userLogin.setImei(reqUserLogin.getImei());
				}

				// 更新登录设备
				userLogin.setLoginEquipment(reqUserLogin.getLoginEquipment());

				// 记录登录时间
				userLogin.setLastLoginTime(new Date());

				// 将newAliasId放入登录响应
				resUserLogin.setAliasId(userLogin.getAliasId());

				// 设置响应body
				dataResponse.setResponseBody(resUserLogin);

				// 响应信息
				setStatus(dataResponse, SystemCode.SUCCESS);

				break;

			case 3:
				// 响应信息-当前用户被锁定
				setStatus(dataResponse, SystemCode.USER_BLOCKED_ERROR);

				break;

			}
		} else if (object instanceof Integer && object.equals(0)) {
			// 用户不存在
			setStatus(dataResponse, SystemCode.USER_INFO_NOT_EXIST_ERROR);
			return;
		} else if (object instanceof Integer && object.equals(1)) {
			// 密码错误
			setStatus(dataResponse, SystemCode.LOGIN_FAIL_ERROR);
			return;
		} else if (object instanceof Integer && object.equals(3)) {
			// 验证码失效或不存在
			setStatus(dataResponse, SystemCode.VALIDATE_THROUGH_ERROR);
			return;
		} else {
			// 没有数据，系统异常
			setStatus(dataResponse, SystemCode.ERROR);
		}
	}

	/**
	 * @Title: validateUserLogin @Description: 验证用户登录时传入的参数是否为空 @param
	 *         reqUserLogin 客户端传入参数 @return false 参数错误 true 参数正确 @throws
	 */
	private boolean validateUserLogin(ReqUserLogin reqUserLogin) {

		if (reqUserLogin == null) {
			return false;
		}
		// 用户名
		if (ToolUtil.isBlank(reqUserLogin.getUserName())) {
			return false;
		}
		// 用户密码
		if (ToolUtil.isBlank(reqUserLogin.getUserPwd())) {
			return false;
		}
		// 登录设备
		if (reqUserLogin.getLoginEquipment() == null) {
			return false;
		}
		// imei
		if (reqUserLogin.getImei() == null) {
			return false;
		}

		// validateNum
		// if(ToolUtil.isBlank(reqUserLogin.getValidateNum())){
		// return false;
		// }
		return true;

	}

	/**
	 * @Title: validateUserLogin @Description: 验证用户登录时传入的参数是否为空 @param
	 *         reqUserLogin 客户端传入参数 @return false 参数错误 true 参数正确 @throws
	 */
	private boolean validateUserLoginByNum(ReqUserLoginByNum reqUserLoginByNum) {

		if (reqUserLoginByNum == null) {
			return false;
		}
		// 用户名
		if (ToolUtil.isBlank(reqUserLoginByNum.getUserName())) {
			return false;
		}

		// 验证码
		if (ToolUtil.isBlank(reqUserLoginByNum.getValidateNum())) {
			return false;
		}

		// 登录设备
		if (reqUserLoginByNum.getLoginEquipment() == null) {
			return false;
		}
		// 手机唯一标识
		if (reqUserLoginByNum.getImei() == null) {
			return false;
		}

		return true;

	}

	/**
	 * 执行注销
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED)
	public void userLogout(ReqUserLogout reqUserLogout, DataResponse dataResponse) {

		// 请求bean或用户id不存在
		if (reqUserLogout == null || reqUserLogout.getUserId() == null) {
			setStatus(dataResponse, SystemCode.DATA_NULL_ERROR);
			return;
		}

		// 创建用户登录对象
		UserLogin userLogin = this.getUserLoginInfo(reqUserLogout.getUserId(), dataResponse);
		// 判断该用户信息是否为空
		if (userLogin == null) {
			return;
		}

		userLogin.setUserStatus(2);
		setStatus(dataResponse, SystemCode.SUCCESS);
	}

	/**
	 * @Title: resetOrderNumber @Description: 重置每日接单次数和取消次数 @author yhq @return
	 *         void @throws
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED)
	public void resetOrderNumber() {

		try {
			//重置每日接单次数、取消次数和提现次数
			super.userLoginDao.updateSqlRow(UserLoginServiceSQL.RESET_ORDER_NUMBER);
			
			//重置验证码验证失败次数
			super.phoneValidateDao.updateSqlRow(UserLoginServiceSQL.RESET_VALIDATE_CODE_NUMBER);
			
		} catch (Exception e) {
			log.error("重置每日接单次数、取消次数和提现次数时出现异常  类" + this.getClass() + " resetOrderNumber()", e);
		}

	}

	/**
	 * @Title: resetOrderNumber @Description: 获取全部用户登录信息(数据迁移专用) @author
	 *         yhq @return void @throws
	 */
	@Override
	@Transactional(readOnly = true)
	public List<UserLogin> getAllUserLogin() {

		return super.userLoginDao.queryAll(false);
	}

	/**
	 * @Title: deleteAllUserLogin @Description: 删除全部用户登录信息(数据迁移专用) @author
	 *         yhq @return void @throws
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public boolean deleteAllUserLogin() {
		// 全部订单
		int row = 0;
		try {
			row = super.userLoginDao.updateSqlRow("DELETE FROM userlogin");
		} catch (Exception e) {
			log.info("删除全部的用户登录信息时出现异常   类：" + this.getClass() + " deleteAllUserLogin()", e);
			return false;
		}

		// 判断删除订单是否成功
		if (row > 0) {
			return true;
		}

		return false;
	}

	/**
	 * @Title: updateAllUserLogin @Description: 修改用户登录Id(数据迁移专用) @param
	 *         userLogins @author yhq @return void @throws
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public boolean updateAllUserLogin(List<UserLogin> userLogins, List<Useraccount> useraccounts,
			List<Userdetail> userdetails, List<Vehicleinfo> vehicleinfos, List<Userorder> userorders) {

		boolean flag = false;

		// 判断返回用户账户列表是否为空
		if (userLogins != null && userLogins.size() > 0) {
			int login = 1;
			for (UserLogin userLogin : userLogins) {

				// 登录用户原账户
				String loginId = userLogin.getUid();

				// 产生一个用户账户Id
				String oid = ToolUtil.getUid();

				userLogin.setUid(oid);
				log.info("登录第" + login + "条");
				try {
					super.userLoginDao.save(userLogin);
					Thread.sleep(1);
				} catch (Exception e) {
					log.info("修改用户账户Id是出现异常   类：" + this.getClass() + " updateAllUserAccount()", e);
					return false;
				}

				/** 用户账户开始 **/
				int account = 1;
				for (Useraccount useraccount : useraccounts) {

					// 查找用户详情中跟用户登录Id相同的
					if (ToolUtil.isNotBlank(useraccount.getLoginId()) && useraccount.getLoginId().equals(loginId)) {

						useraccount.setLoginId(oid);
						log.info("账户第" + account + "条");
						try {
							super.userAccountDao.update(useraccount);
						} catch (Exception e) {
							log.info("修改用户详情中的用户Id时出现异常   类：" + this.getClass() + " updateAllUserLogin()", e);
							flag = true;
							return false;
						}
					}
					account++;

				}

				/** 用户账户结束 **/

				if (flag) {
					return false;
				}

				/** 用户详情开始 **/
				int detail = 1;
				for (Userdetail userdetail : userdetails) {

					// 查找用户详情中跟用户登录Id相同的
					if (ToolUtil.isNotBlank(userdetail.getLoginId()) && userdetail.getLoginId().equals(loginId)) {

						userdetail.setLoginId(oid);
						log.info("详情第" + detail + "条");
						try {
							super.userDetailDao.update(userdetail);
						} catch (Exception e) {
							log.info("修改用户账户中的用户Id时出现异常   类：" + this.getClass() + " updateAllUserLogin()", e);
							flag = true;
							return false;
						}
					}
					detail++;

				}

				/** 用户详情结束 **/

				if (flag) {
					return false;
				}

				/** 车辆开始 **/
				int vehicle = 1;
				for (Vehicleinfo vehicleinfo : vehicleinfos) {

					// 查找用户详情中跟用户登录Id相同的
					if (ToolUtil.isNotBlank(vehicleinfo.getLoginId()) && vehicleinfo.getLoginId().equals(loginId)) {

						vehicleinfo.setLoginId(oid);
						log.info("审核车主第" + vehicle + "条");
						try {
							super.vehicleinfoDao.update(vehicleinfo);
						} catch (Exception e) {
							log.info("修改车主审核信息中的用户Id时出现异常   类：" + this.getClass() + " updateAllUserLogin()", e);
							flag = true;
							return false;
						}
					}
					vehicle++;

				}

				/** 车辆结束 **/

				if (flag) {
					return false;
				}

				/** 订单开始 **/
				int order = 1;
				for (Userorder userorder : userorders) {

					// 查找用户详情中跟用户登录Id相同的
					if (ToolUtil.isNotBlank(userorder.getPlaceOrderUserId())
							&& userorder.getPlaceOrderUserId().equals(loginId)) {

						userorder.setPlaceOrderUserId(oid);
						log.info("订单第" + order + "条");
						try {
							super.userOrderDao.update(userorder);
						} catch (Exception e) {
							log.info("修改订单中下单用户Id时出现异常   类：" + this.getClass() + " updateAllUserLogin()", e);
							flag = true;
							return false;
						}

					} else if (ToolUtil.isNotBlank(userorder.getGrabOrderUserId())
							&& userorder.getGrabOrderUserId().equals(loginId)) {

						userorder.setGrabOrderUserId(oid);
						try {
							super.userOrderDao.update(userorder);
						} catch (Exception e) {
							log.info("修改订单的抢单用户Id时出现异常   类：" + this.getClass() + " updateAllUserLogin()", e);
							flag = true;
							return false;
						}

					}
					order++;
				}
				/** 订单结束 **/

				if (flag) {
					return false;
				}
				login++;
			}
			return true;
		}

		return false;
	}

	/**
	 * 
	 * @Title: userLoginByNum 
	 * @Description: 验证码用户登录 
	 * @param reqUserLoginByNum 客户端-用户登录请求bean 
	 * @param dataResponse 
	 * @author Li Yi 
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
	public void userLoginByNum(ReqUserLoginByNum reqUserLoginByNum, DataResponse dataResponse) {
		// 验证用户登录时客户端传入参数是否为空
		boolean isTrue = this.validateUserLoginByNum(reqUserLoginByNum);

		if (!isTrue) {
			log.error("登录请求参数存在空值:" + reqUserLoginByNum.toString());
			setStatus(dataResponse, SystemCode.DATA_NULL_ERROR);
			return;
		}

		// 用于接收所查询出的用户登录信息
		Object object = null;

		ResUserLoginByNum resUserLoginByNum = new ResUserLoginByNum();

		String validateNum = reqUserLoginByNum.getValidateNum();

		
		// 获取验证码对象
		Phonevalidate phonevalidate = getPhonevalidate(reqUserLoginByNum.getUserName(), dataResponse);

		if(phonevalidate == null){
			// 用户名或验证码错误
			setStatus(dataResponse, SystemCode.LOGIN_FAIL_ERROR);
			return;
		}
		
		try {
			// 查询用户，并得到用户详情ResUserLogin bean
			object = super.userLoginDao.getUserInfoByNum(reqUserLoginByNum, resUserLoginByNum, phonevalidate);

		} catch (Exception e) {
			log.error("用户登录异常, 类：" + this.getClass() + "userLogin()", e);
			setStatus(dataResponse, SystemCode.ERROR);// 网络异常
			return;
		}

		if(object instanceof Integer && object.equals(2)){
			
			//验证码剩余次数
			validateFailNumber = 5 - phonevalidate.getValidateCodeNumber();
			
			setStatus(dataResponse, SystemCode.VALIDATE_NOT_THROUGH_ERROR);// 验证码输入错误
			return ;
		}else if(object instanceof Integer && object.equals(4)){
			setStatus(dataResponse, SystemCode.VALIDATE_THROUGH_ERROR);// 验证码失效
			return ;
		}else if(object instanceof Integer && object.equals(0)){
			
			//如果用户不存在，判断其输入的验证码是否正确，如果不正确则驳回
			if(!phonevalidate.getValidateNum().equals(validateNum)){
				
				//验证码剩余次数
				validateFailNumber = 5 - phonevalidate.getValidateCodeNumber();
				
				setStatus(dataResponse, SystemCode.VALIDATE_NOT_THROUGH_ERROR);// 验证码输入错误
				return ;
			}
			
		}
		
		if (object instanceof UserLogin) {
			userlogining(reqUserLoginByNum, dataResponse, object, resUserLoginByNum);
		} // 如果该用户为新用户 ，则初始化该用户信息
		else if (object instanceof Integer && object.equals(0)) {
			// 新用户第一次登录，进行初始化
			userInitializing(reqUserLoginByNum, dataResponse, resUserLoginByNum);
		} else if (object instanceof Integer && object.equals(1)) {
			// 用户名或验证码错误
			setStatus(dataResponse, SystemCode.LOGIN_FAIL_ERROR);
			return;
		} else if (object instanceof Integer && object.equals(3)) {
			// 验证码失效
			setStatus(dataResponse, SystemCode.VALIDATE_THROUGH_ERROR);
			return;
		} else {
			// 没有数据，系统异常
			setStatus(dataResponse, SystemCode.ERROR);
		}

	}
	

	private void userlogining(ReqUserLoginByNum reqUserLoginByNum, DataResponse dataResponse, Object object,
			ResUserLoginByNum resUserLoginByNum) {
		// 将返回值强转为UserLogin
		UserLogin userLogin = (UserLogin) object;
		
		// 设定用户状态(3:锁定  1:登录状态  2:退出状态)
		int status = userLogin.getUserStatus();
		
		// 新的别名
		String newAliasId = ToolUtil.getUid();

		//更新用户当前城市
		super.userDetailDao.updateCurrentCity(userLogin.getUid(), reqUserLoginByNum.getCurrentCity());
		
		/**
		 * 修改人：冯硕楠
		 * 修改原因：添加出租车业务需求，需要判断车主为私家车还是出租车
		 * 修改时间：2016年6月30日13:28:04
		 * 修改版本：V2.3
		 */
		//判断如果是车主
		Vehicleinfo vehicleinfo = super.vehicleinfoDao.getVehicleinfo(userLogin.getUid());
		
		if(vehicleinfo != null){
			
			Integer regis = vehicleinfo.getRegistrationType();
			if(regis != null){
				resUserLoginByNum.setRegistrationType(regis);
			}
		}else{
			resUserLoginByNum.setRegistrationType(0);//初始值为0
		}
		
		// 进行状态判定
		switch (status) {

		// 已退出
		case 2:

			// 更新登录设备
			userLogin.setLoginEquipment(reqUserLoginByNum.getLoginEquipment());

			// 改变用户登录状态
			userLogin.setUserStatus(1);

			// 更新别名
			userLogin.setAliasId(newAliasId);

			// 更新手机标识
			userLogin.setImei(reqUserLoginByNum.getImei());

			//当前用户APP版本号
			userLogin.setClientVersion(reqUserLoginByNum.getClientVersion());
			
			// 记录登录时间
			userLogin.setLastLoginTime(new Date());

			// 将newAliasId放入登录响应
			resUserLoginByNum.setAliasId(newAliasId);

			if (userLogin.getIsAttendActivity() == 1) { // 未参加过活动
				// 添加优惠券
				boolean flag = addCoupon(dataResponse, userLogin.getUid());
				
				if(flag){
					userLogin.setIsAttendActivity(2); //标示已参加活动
					userLogin.setCouponNumber(userLogin.getCouponNumber() + 2);
				}
				
			}

			resUserLoginByNum.setAccessToken(java.util.UUID.randomUUID().toString());
			// 响应请求
			dataResponse.setResponseBody(resUserLoginByNum);

			// 登录成功
			setStatus(dataResponse, SystemCode.SUCCESS);// 200

			break;

		// 已登录
		case 1:

			// 如果请求的imei号为空或者与当前存的imei号不一致
			if (!reqUserLoginByNum.getImei().equals(userLogin.getImei())) {

				// 推送Bean
				PushData pushData = new PushData();

				// 推送序号(时间戳)
				pushData.setRequestNumber(DateFormatUtil.getTimeInMillis().toString());
				// 推送时间
				pushData.setRequestTime(DateFormatUtil.yyyy_MM_dd_HHmmss());
				// 模块
				pushData.setModular(ServiceCode.USER_LOGIN);
				// 响应内容
				PushUserLogin pushUserLogin = new PushUserLogin(DateFormatUtil.yyyy_MM_dd_HHmmss(),
						reqUserLoginByNum.getLoginEquipment() == 1 ? "iOS" : "Android");

				pushData.setResponseBody(pushUserLogin);

				String json = JSONUtil.toJSONString(pushData);

				// 面向用户推送信息
				SendPushUtil.sendPush(userLogin.getAliasId(), "", "", json,
						userLogin.getLoginEquipment() == 1 ? "iOS" : "Android");

				// 推送后更新用户新的极光别名
				userLogin.setAliasId(newAliasId);

				// 推送后更新用户新的手机标识
				userLogin.setImei(reqUserLoginByNum.getImei());
			}

			// 更新登录设备
			userLogin.setLoginEquipment(reqUserLoginByNum.getLoginEquipment());

			//当前用户APP版本号
			userLogin.setClientVersion(reqUserLoginByNum.getClientVersion());
			
			// 记录登录时间
			userLogin.setLastLoginTime(new Date());

			// 将newAliasId放入登录响应
			resUserLoginByNum.setAliasId(userLogin.getAliasId());

			if (userLogin.getIsAttendActivity() == 1) { // 未参加过活动
				// 添加优惠券
				addCoupon(dataResponse, userLogin.getUid());
			}

			resUserLoginByNum.setAccessToken(java.util.UUID.randomUUID().toString());
			
			// 设置响应body
			dataResponse.setResponseBody(resUserLoginByNum);

			// 响应信息
			setStatus(dataResponse, SystemCode.SUCCESS);

			break;

		case 3:
			// 响应信息-当前用户被锁定
			setStatus(dataResponse, SystemCode.USER_BLOCKED_ERROR);

			break;

		}

	}
	

	/** 第一次注册设置ReqUserLoginByNum响应 Bean **/
	private void toResUserLoginNum(ReqUserLoginByNum reqUserLoginByNum, DataResponse dataResponse,
			ResUserLoginByNum resUserLoginByNum, String userLoginId, String newAliasId) {
		resUserLoginByNum.setLoginId(userLoginId);
		resUserLoginByNum.setUserRole(2);
		resUserLoginByNum.setIsDeposit(1);
		resUserLoginByNum.setNickName("叮叮小伙伴");
		resUserLoginByNum.setTellphone(reqUserLoginByNum.getUserName());
		resUserLoginByNum.setSex(1);
		resUserLoginByNum.setUserAvatar(ToolUtil.imageAddress("defaultAvatar.jpg"));
		resUserLoginByNum.setUserTabloidAvatar(ToolUtil.imageAddress("thumbnail_defaultAvatar.jpg"));
		resUserLoginByNum.setVstatus(0);
		resUserLoginByNum.setAliasId(newAliasId);
		resUserLoginByNum.setAccessToken(java.util.UUID.randomUUID().toString());
		resUserLoginByNum.setRegistrationType(0);//初始值为0
		dataResponse.setResponseBody(resUserLoginByNum);
		setStatus(dataResponse, SystemCode.SUCCESS);
	}

	/**
	 * 用户信息初始化
	 * @param resUserLoginByNum
	 **/
	public void userInitializing(ReqUserLoginByNum reqUserLoginByNum, DataResponse dataResponse,
			ResUserLoginByNum resUserLoginByNum) {
		// 生成用户登录ID(根据当前时间戳和六位随机数拼接成一个用户的登录Id)
		String userLoginId = ToolUtil.getUid();
		// 生成用户详情ID
		String userDetailId = ToolUtil.getUid();
		// 生成用户账户ID
		String userAccountId = ToolUtil.getUid();
		// 生成用户积分ID
		String userIntegralId = ToolUtil.getUid();
		// 生成用户车主认证信息ID
		String vehicleinfoId = ToolUtil.getUid();
		// 极光推送别名
		String newAliasId = ToolUtil.getUid();

		// 用户登录信息保存到数据库
		try {
			super.userLoginDao.saveUserLoginByNum(reqUserLoginByNum, userLoginId, newAliasId);

		} catch (Exception e) {
			log.error("用户注册保存 登录表 存储发生异常, 类：" + this.getClass() + " 方法：userRegister()",e);
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 用户详情信息保存到数据库
		try {
			super.userDetailDao.saveUserDetailByNum(reqUserLoginByNum, userLoginId, userDetailId,resUserLoginByNum);
		} catch (Exception e) {
			log.error("用户注册保存 用户详情表 发生异常, 类：" + this.getClass() + " 方法：userRegister()");
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 用户账户信息保存到数据库
		try {

			super.userAccountDao.saveUserAccountByNum(reqUserLoginByNum, userAccountId, userLoginId);
		} catch (Exception e) {
			log.error("用户注册保存 账户信息表发生异常, 类：" + this.getClass() + " 方法：userRegister()");
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 用户积分信息保存到数据库
		try {
			super.userIntegralDao.saveUserIntegralByNum(reqUserLoginByNum, userIntegralId, userLoginId);
		} catch (Exception e) {
			log.error("用户注册保存 积分信息表 发生异常, 类：" + this.getClass() + " 方法：userRegister()");
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 用户车主认证信息保存到数据库
		try {
			super.vehicleinfoDao.saveVehicleInfoByNum(vehicleinfoId, userLoginId);
		} catch (Exception e) {
			log.error("用户注册保存 车主认证表 发生异常, 类：" + this.getClass() + " 方法：userRegister()");
			setStatus(dataResponse, SystemCode.ERROR);
			return;
		}

		// 添加优惠券
//		addCoupon(dataResponse, userLoginId);

		toResUserLoginNum(reqUserLoginByNum, dataResponse, resUserLoginByNum, userLoginId, newAliasId);
	}

	/**
	 * 
	 * @Title: addCoupon 
	 * @Description: 添加优惠券操作类
	 * @param dataResponse
	 * @param userLoginId 用户ID 
	 * @author CHEHAUNBO
	 * 
	 */

	private Boolean addCoupon(DataResponse dataResponse, String userLoginId) {

		// 添加优惠券
		try {
			return super.userCouponDao.addUserCoupon(userLoginId);
		} catch (Exception e) {
			log.error("给新用户赠送优惠券时出现异常  类：" + this.getClass() + " 方法：userRegister()", e);
			setStatus(dataResponse, SystemCode.ERROR);
			return false;
		}

	}
	
	
	/**
	 * @Description:通过用户角色设置车主或
	 * @author fengshuonan
	 * @return void
	 */
	private void changeRegistrationTypeByUserRole(){
		
	}

}